"use strict";

const { browserService } = require("./browser");
const { logger } = require("ee-core/log");
const { ChildJob, ChildPoolJob } = require("ee-core/jobs");

/**
 * douyin
 * @class
 */
class DouyinService {
  constructor() {
    // 在构造函数中初始化一些变量
    this.myTimer = null;
    this.myJob = new ChildJob();
    this.myJobPool = new ChildPoolJob();
    this.taskForJob = {};
    this.browserService = browserService;
  }

  /**
   * test
   */
  async test(args) {
    let obj = {
      status: "ok",
      params: args,
    };
    logger.info("douyinService obj:", obj);
    return obj;
  }

  /**
   * ipc通信(双向)
   */
  bothWayMessage(type, content, event) {
    // 前端ipc频道 channel
    const channel = "controller/douyin/ipcSendMsg";
    if (type == "start") {
      // 每隔1秒，向前端页面发送消息
      // 用定时器模拟
      this.myTimer = setInterval(
        function (e, c, msg) {
          let timeNow = Date.now();
          let data = msg + ":" + timeNow;
          e.reply(`${c}`, data);
        },
        1000,
        event,
        channel,
        content
      );
      return "开始了";
    } else if (type == "end") {
      clearInterval(this.myTimer);
      return "停止了";
    } else {
      return "ohther";
    }
  }

  /**
   * 执行任务
   */
  async doJob(jobId, action, event) {
    let res = {};
    let oneTask;
    const channel = "controller/douyin/timerJobProgress";
    const msgChannel = "controller/global/message";
    if (action == "create") {
      const context = await this.browserService.getBrowserContext("SP1");
      if (!context) {
        event.sender.send(`${msgChannel}`, {
          type: "error",
          msg: "游览器启动失败",
        });
        return {};
      }
      event.sender.send(`${msgChannel}`, {
        type: "success",
        msg: "游览器启动成功",
      });
      // 执行任务及监听进度
      let eventName = "job-timer-progress-" + jobId;
      const timerTask = this.myJob.exec("./douyin/task/timer", { jobId });
      timerTask.emitter.on(eventName, (data) => {
        logger.info("[main-process] timerTask, from TimerJob data:", data);
        // 发送数据到渲染进程
        event.sender.send(`${channel}`, data);
      });
      res.pid = timerTask.pid;
      this.taskForJob[jobId] = timerTask;
    }
    if (action == "close") {
      oneTask = this.taskForJob[jobId];
      oneTask.kill();
      event.sender.send(`${channel}`, { jobId, number: 0, pid: 0 });
    }
    if (action == "pause") {
      oneTask = this.taskForJob[jobId];
      oneTask.callFunc("./douyin/task/timer", "pause", jobId);
    }
    if (action == "resume") {
      oneTask = this.taskForJob[jobId];
      oneTask.callFunc("./douyin/task/timer", "resume", jobId, oneTask.pid);
    }

    return res;
  }

  /**
   * 创建pool
   */
  doCreatePool(num, event) {
    const channel = "controller/douyin/createPoolNotice";
    this.myJobPool.create(num).then((pids) => {
      event.reply(`${channel}`, pids);
    });
  }

  /**
   * 通过进程池执行任务
   */
  doJobByPool(jobId, action, event) {
    let res = {};
    const channel = "controller/douyin/timerJobProgress";
    if (action == "run") {
      // 异步-执行任务及监听进度
      this.myJobPool
        .runPromise("./jobs/example/timer", { jobId })
        .then((task) => {
          // 监听器名称唯一，否则会出现重复监听。
          // 任务完成时，需要移除监听器，防止内存泄漏
          let eventName = "job-timer-progress-" + jobId;
          task.emitter.on(eventName, (data) => {
            logger.info(
              "[main-process] [ChildPoolJob] timerTask, from TimerJob data:",
              data
            );

            // 发送数据到渲染进程
            event.sender.send(`${channel}`, data);

            // 如果收到任务完成的消息，移除监听器
            if (data.end) {
              task.emitter.removeAllListeners(eventName);
            }
          });

          res.pid = task.pid;
        });
    }
    return res;
  }
}
DouyinService.toString = () => "[class DouyinService]";

module.exports = {
  DouyinService,
  douyinService: new DouyinService(),
};
